home *** CD-ROM | disk | FTP | other *** search
/ Amiga Collections: Various / DevDisk 65 (1989)(DevWare PD).zip / DevDisk 65 (1989)(DevWare PD).adf / prosuite / xtext.asm < prev    next >
Assembly Source File  |  1990-07-11  |  19KB  |  611 lines
  1.  
  2. * *** xtext.asm *************************************************************
  3. *
  4. * XText  --  The XText Routine
  5. * (from the FastText algorithms created in January, 1986)
  6. *   from Book 1 of the Amiga Programmers' Suite by RJ Mical
  7. *
  8. * Copyright (C) 1986, 1987, Robert J. Mical
  9. * All Rights Reserved.
  10. *
  11. * Created for Amiga developers.
  12. * Any or all of this code can be used in any program as long as this
  13. * entire copyright notice is retained, ok?  Thanks.
  14. *
  15. * The Amiga Programmer's Suite Book 1 is copyrighted but freely distributable.
  16. * All copyright notices and all file headers must be retained intact.
  17. * The Amiga Programmer's Suite Book 1 may be compiled and assembled, and the 
  18. * resultant object code may be included in any software product.  However, no 
  19. * portion of the source listings or documentation of the Amiga Programmer's 
  20. * Suite Book 1 may be distributed or sold for profit or in a for-profit 
  21. * product without the written authorization of the author, RJ Mical.
  22. * 
  23. * HISTORY       Name             Description
  24. * ------------  ---------------  -------------------------------------------
  25. * 27 Oct 86     RJ Mical >:-{)*  Translated this file.
  26. *
  27. * ***************************************************************************
  28.  
  29.     INCLUDE "xtext.i"
  30.  
  31.  
  32.     IFND    AZTEC ; If AZTEC not defined, do it the standard way
  33.     XDEF    _XText
  34.     XREF    _custom
  35.     XREF    _GfxBase
  36.     ENDC
  37.     IFD    AZTEC ; If AZTEC defined, do it the non-standard way (sigh)
  38.     PUBLIC    _XText
  39.     PUBLIC    _custom
  40.     PUBLIC    _GfxBase
  41.     ENDC
  42.  
  43.  
  44.  
  45. _XText:
  46. * ***************************************************************************
  47. * These FastText algorithms were created by =Robert J. Mical= in January 1986
  48. * Copyright (C) 1986, =Robert J. Mical=
  49. * All Rights Reserved
  50. *
  51. * This is my brute-force XText() routine.
  52. * It presumes many things about text:  that the characters come in
  53. * pairs, that the characters are 8-bits wide (this one is not easily 
  54. * undone), and more.
  55. *
  56. * The theory of operation here is that I will build a single plane of
  57. * normal characters (character data bits set, background bits clear)
  58. * in the Normal Text Plane, using the data from the Output Characters
  59. * Buffer.  As needed, I will invert this plane (character bits clear,
  60. * background bits set) into the Inverted Text Plane.  There's two other
  61. * globally accessible (pre-initialized) planes used:  an AllClearPlane plane
  62. * of all bits clear, and an AllSetPlane plane of all bits set.
  63. *
  64. * Using these four planes, I can construct a bitmap of all possible pen
  65. * settings for the foreground and background.  If corresponding bits
  66. * in the FgPen and BgPen are:
  67. *        -----      -----
  68. *          0       0        Use All Clear Plane
  69. *          0       1        Use Inverted Text Plane
  70. *          1       0        Use Normal Text Plane
  71. *          1       1        Use All Set Plane
  72. *
  73. * Note that if FgPen and BgPen are equal, I don't have to bother
  74. * constructing the Normal or Inverted Text Planes, since they'll
  75. * never be used.
  76. *
  77. * An optimization that evolves out of this fact is that you can fill a line
  78. * or part of a line of your text with spaces (blank characters) much more
  79. * quickly by setting the foreground pen equal to the background pen.  The
  80. * trick with this optimization is to not spend too much time detecting
  81. * whether or not an area of text is all blank, for you may lose the
  82. * increased performance during the handling of normal text lines.
  83. *
  84. * A further optimization is that I'm guessing that many text calls
  85. * will not require the inverted plane, so I won't make it until I 
  86. * discover that I need it.  If programmers follow the
  87. * Intuition-encouraged standard of pen 1 for foreground and pen 0
  88. * for background, then the bits are:  FgPen -- 00001
  89. *                                     BgPen -- 00000
  90. * In fact, if the text is *any* color against a background of zero,
  91. * this optimization works.
  92. *
  93. * For example, the plain PC monochrome text turns out to be pen 1 on
  94. * pen 0.  No need to invert here!
  95. *
  96. * So I won't bother constructing the inverted plane until I discover
  97. * that it's needed.  The cost of this is that I have to check a flag
  98. * once per time that I find an inverted bit plane is called for (6 times 
  99. * maximum (though of course Dale would say 8 times maximum)), and the 
  100. * savings is avoiding an unnecessary inversion.
  101. *
  102. * Note that this routine works with character pairs while building the
  103. * buffer.  If you specify an odd number of characters, this routine will 
  104. * round up the character count to the next higher even number, and then 
  105. * build the buffer with that many characters.  However, only the number
  106. * of characters you specify will actually be printed to the screen.
  107. *
  108. * ON ENTRY (on stack):
  109. *       ARG0 = address of the XTextSupport structure
  110. *       ARG1 = address of the text string
  111. *       ARG2 = character count
  112. *       ARG3 = x position for text output
  113. *       ARG4 = y position for text output
  114.  
  115. DREGS EQU    0      ; Offset to the pushed D-Registers
  116. DREGCOUNT EQU    6      ; How many D-Registers were pushed
  117. AREGS EQU    (DREGS+(DREGCOUNT*4)) ; Offset to the pushed A-Registers
  118. AREGCOUNT EQU    5
  119. FRONTPEN EQU    (AREGS+(AREGCOUNT*4))    ; Local variable
  120. BACKPEN  EQU    (FRONTPEN+2)    ; Local variable
  121. DRAWMODE EQU    (BACKPEN+2) ; Local variable
  122. XBLTSIZE EQU    (DRAWMODE+2)
  123. RETADDR  EQU    (XBLTSIZE+2)    ; Our return address
  124. ARG0  EQU    (RETADDR+4) ; Offset to passed arguments
  125. ARG1  EQU    (ARG0+4)
  126. ARG2  EQU    (ARG1+4)
  127. ARG3  EQU    (ARG2+4)
  128. ARG4  EQU    (ARG3+4)
  129.  
  130.  
  131.     LEA    -8(SP),SP        ; Reserve memory for local variables
  132.     MOVEM.L A2-A6/D2-D7,-(SP)
  133.  
  134.  
  135.     MOVE.L    ARG0(SP),A2    ; Get the XTextSupport structure address
  136.     MOVE.L    #_custom,A5    ; Get the address of the custom chip
  137.     MOVE.L    _GfxBase,A6    ; Load up A6 for graphics calls
  138.  
  139.  
  140. * Check the character count.
  141. * If it's zero, then split as there's nothing to do.
  142. * If it's less than zero, this is the signal that the programmer
  143. * wants *us* to figure out how long the string is.  Nice touch, eh?
  144. * If it's greater than zero, then presume it's valid.
  145.     MOVE.W    ARG2+2(SP),D2    ; Get the character count
  146.     BEQ    RETURN        ; and split if there's none to do
  147.     BGT    GOT_TEXT_COUNT    ; If greater than zero, then it's real
  148.  
  149.     MOVE.L    ARG1(SP),A4    ; Address of text string
  150.     MOVEQ.L    #-1,D2        ; Start with less than no characters
  151. 10$    ADDQ.W    #1,D2        ; Increment character count
  152.     TST.B    (A4)+        ; Test if next is end of text
  153.     BNE    10$        ; Branch if not
  154.  
  155.     MOVE.W    D2,ARG2+2(SP)    ; Save as character count
  156.  
  157. GOT_TEXT_COUNT:
  158. * The result of the following 3 instructions is created by the 2 below
  159. * I include this commentary to keep things from getting confusing
  160. *  ADDQ  #1,D2     ; to round up
  161. *  LSR.B #1,D2     ; Turn the char count into a pair count
  162. *  SUBQ.W    #1,D2     ; (-1 for DBRA of PAIRLOOP below)
  163.     SUBQ.B    #1,D2
  164.     LSR.B    #1,D2
  165.  
  166.  
  167.     CALLSYS OwnBlitter    ; Get that blitter
  168.  
  169.  
  170. * Get local copies of the pens, jazzed around to take the DrawMode into
  171. * account.  Namely, if JAM1 then the background pen is automatically zero,
  172. * and if the INVERSVID flag is set then swap the foreground/background pens
  173.  
  174.     CLEAR    D3        ; Save them as words
  175.     MOVE.B    xt_FrontPen(A2),D3 ; Load up the local front pen
  176.     CLEAR    D4        ; Start out presuming that back is zero
  177.     MOVE.B    xt_DrawMode(A2),D5 ; Test the draw mode 
  178.     MOVE.B    D5,D6        ; Save a copy
  179.     ANDI.W    #3,D5        ; Strip off INVERSVID (and any other) bit
  180.     MOVE.W    D5,DRAWMODE(SP)    ; and save the true drawmode
  181.     CMP.B    #RP_JAM1,D5    ; Is it JAM1?
  182.     BEQ    1$        ; If it's JAM1, leave the local back as zero
  183.     MOVE.B    xt_BackPen(A2),D4 ; else load up the local back pen
  184.  
  185. 1$    ANDI.B    #RP_INVERSVID,D6 ; Was INVERSVID bit set?
  186.     BEQ    2$        ; and skip if not
  187.     EXG    D3,D4        ; else exchange the pen registers
  188.  
  189. 2$
  190.     MOVE.W    D3,FRONTPEN(SP)    ; Save the local front pen
  191.     MOVE.W    D4,BACKPEN(SP)    ; Save the local back pen
  192.  
  193.  
  194.     MOVE.W    xt_CharHeight(A2),D6    ; Build the bltsize word
  195.     LSL.W    #6,D6        ; Height is shifted over as blitter likes it
  196.     MOVE.W    D6,XBLTSIZE(SP)    ; Save this partial for later
  197.  
  198.  
  199.     CMP.W    D3,D4        ; Are the pens equal?
  200.     BEQ    PLANESET    ; If so, skip building the planes
  201.  
  202.  
  203. * Wait 'til any blitting is done, and then initialize 
  204. * the blitter for my personal use ...
  205.     CALLSYS    WaitBlit    ; and wait for that baby to be free!
  206.  
  207.  
  208.     CLEAR    D3
  209.     MOVE.W    D3,bltamod(A5)    ; Set up the SRCA and SRCB modulos
  210.     MOVE.W    D3,bltbmod(A5)
  211.     SUBI.W    #1,D3
  212.     MOVE.W    D3,bltafwm(A5)    ; Masks are all set
  213.     MOVE.W    D3,bltalwm(A5)
  214.  
  215.     CLEAR    D3
  216.     MOVE.B    xt_MaxTextWidth(A2),D3
  217.     SUBQ.W    #2,D3
  218.     MOVE.W    D3,bltdmod(A5)
  219.     MOVE.W    #$0DFC,bltcon0(A5)    ; Use ABD, minterm is A or B, don't
  220.     MOVE.W    #$8000,bltcon1(A5)    ; shift A, shift B by 8
  221.  
  222.     MOVE.L    xt_NormalTextPlane(A2),D3 ; Address of the normal text plane
  223.  
  224.     MOVE.W    xt_FontSelect(A2),D6    ; Get the address of the font data
  225.     LSL.W    #2,D6
  226.     LEA    xt_FontData(A2),A3
  227.     ADD.W    D6,A3
  228.     MOVE.L    (A3),A3
  229.     MOVE.L    ARG1(SP),A4    ; Address of text string
  230.  
  231.     MOVE.W    xt_CharHeight(A2),D7
  232.  
  233.     MOVE.W    xt_Flags(A2),D6    ; Get the Flags
  234.     ANDI    #SLIM_XTEXT,D6    ; and test if the programmer wants SLIM_XTEXT
  235.     BNE    SLIM_CHARS    ; and go build the text the "slim" way if so
  236.                 ; else we're doing text the faster "fat" way
  237.  
  238.     MOVE.W    XBLTSIZE(SP),D6    ; Get the blit size partial
  239.     ORI    #1,D6        ; and make blit size one word wide
  240.  
  241.     CMPI    #8,D7        ; Can we do fast building?
  242.     BNE    SLOW_PAIRLOOP    ; If not 8, do it the "slow" way
  243.  
  244.  
  245. PAIRLOOP:
  246. * The normal text plane is constructed here.
  247. * Do as much pre-calculating as possible before actually waiting for the
  248. * blitter to be ready for re-use.
  249.  
  250.  
  251.     CLEAR    D4        ; Get the address of the font data of
  252.     MOVE.B    (A4)+,D4    ; the next character
  253.     LSL.W    #4,D4        ; (This presumes that each char is 16 bytes)
  254.     ADD.L    A3,D4
  255.  
  256.     CLEAR    D5        ; Get font data of next in pair (if there's
  257.     MOVE.B    (A4)+,D5    ; not really a second character (odd-numbered
  258.     LSL.W    #4,D5        ; string lengths) then this second move of
  259.     ADD.L    A3,D5        ; data will be unnecessary, but at least is
  260.                 ; harmless since the buffer is *always*
  261.                 ; pair-sized and the speed improvement is
  262.                 ; great when handling two characters at once)
  263.  
  264.     CALLSYS    WaitBlit    ; (this is redundant the first time through)
  265.  
  266.     MOVE.L    D4,bltapt(A5)
  267.     MOVE.L    D5,bltbpt(A5)
  268.     MOVE.L    D3,bltdpt(A5)
  269.  
  270.     MOVE.W    D6,bltsize(A5)    ; Bombs away!
  271.  
  272.     ADDQ.L    #2,D3        ; Advance destination pointer to next word
  273.  
  274.     DBRA    D2,PAIRLOOP
  275.  
  276. * Done, so go start setting up the planes 
  277.     BRA    PLANESET
  278.  
  279.  
  280. SLOW_PAIRLOOP:
  281. * The normal text plane is constructed here.
  282. * Done the "slow" way using a MULU because the character height isn't 8.
  283. * Do as much pre-calculating as possible before actually waiting for the
  284. * blitter to be ready for re-use.
  285.  
  286.  
  287.     CLEAR    D4        ; Get the address of the font data of
  288.     MOVE.B    (A4)+,D4    ; the next character
  289.     ADD.W    D4,D4
  290.     MULU    D7,D4        ; Offset * 2 * CharHeight
  291.     ADD.L    A3,D4
  292.  
  293.     CLEAR    D5        ; Get font data of next in pair (if there's
  294.     MOVE.B    (A4)+,D5    ; not really a second character (odd-numbered
  295.     ADD.W    D5,D5        ; string lengths) then this second move of
  296.     MULU    D7,D5
  297.     ADD.L    A3,D5        ; data will be unnecessary, but at least is
  298.                 ; harmless since the buffer is *always*
  299.                 ; pair-sized and the speed improvement is
  300.                 ; great when handling two characters at once)
  301.  
  302.     CALLSYS    WaitBlit    ; (this is redundant the first time through)
  303.  
  304.     MOVE.L    D4,bltapt(A5)
  305.     MOVE.L    D5,bltbpt(A5)
  306.     MOVE.L    D3,bltdpt(A5)
  307.  
  308.     MOVE.W    D6,bltsize(A5)    ; Bombs away!
  309.  
  310.     ADDQ.L    #2,D3        ; Advance destination pointer to next word
  311.  
  312.     DBRA    D2,SLOW_PAIRLOOP
  313.  
  314. * Done, so go start setting up the planes 
  315.     BRA    PLANESET
  316.  
  317.  
  318.  
  319. SLIM_CHARS:
  320. * OK, the programmer asked for SLIM_XTEXT, which is the half-size memory 
  321. * buffer for text to be built using the processor rather than the blitter
  322.  
  323.     MOVE.L    A5,-(SP)        ; Save A5 during the SLIM build
  324.  
  325.     CLEAR    D0            ; Build the byte-size modulo
  326.     MOVE.B    xt_MaxTextWidth(A2),D0
  327.     SUBQ    #1,D0
  328.  
  329.     MOVE.W    D7,D1            ; Build the line height (-1 for DBRA)
  330.     SUBQ    #1,D1
  331.     CMPI    #8,D7            ; Can we do fast building?
  332.     BNE    SLIM_SLOW_PAIRLOOP    ; If not 8, do it the "slow" way
  333.  
  334.  
  335. SLIM_PAIRLOOP:
  336. * The normal "slim" text plane is constructed here.
  337.  
  338.     CLEAR    D4        ; Get the address of the font data of
  339.     MOVE.B    (A4)+,D4    ; the next character
  340.     LSL.W    #3,D4        ; (This presumes that each char is 8 bytes)
  341.     ADD.L    A3,D4
  342.     MOVE.L    D4,A0
  343.  
  344.     CLEAR    D5        ; Get font data of next in pair (if there's
  345.     MOVE.B    (A4)+,D5    ; not really a second character (odd-numbered
  346.     LSL.W    #3,D5        ; string lengths) then this second move of
  347.     ADD.L    A3,D5        ; data will be unnecessary, but at least is
  348.     MOVE.L    D5,A1
  349.                 ; harmless since the buffer is *always*
  350.                 ; pair-sized and the speed improvement is
  351.                 ; great when handling two characters at once)
  352.  
  353.     MOVE.W    D1,D6        ; Build the bltsize word
  354.     MOVE.L    D3,A5
  355.  
  356. SLIM_BUILD:
  357.     MOVE.B    (A0)+,(A5)+
  358.     MOVE.B    (A1)+,(A5)
  359.     ADD.L    D0,A5
  360.     DBRA    D6,SLIM_BUILD
  361.  
  362.     ADDQ.L    #2,D3        ; Advance destination pointer to next word
  363.  
  364.     DBRA    D2,SLIM_PAIRLOOP ; Count down the character pairs to print 
  365.  
  366.     MOVE.L (SP)+,A5        ; Restore A5 at end of SLIM_BUILD 
  367.  
  368. * Done, so go start setting up the planes 
  369.     BRA    PLANESET
  370.  
  371.  
  372.  
  373. SLIM_SLOW_PAIRLOOP:
  374. * The normal "slim" text plane is slowly constructed here, slow because 
  375. * the characters are other than 8 lines tall.
  376.  
  377.     CLEAR    D4        ; Get the address of the font data of
  378.     MOVE.B    (A4)+,D4    ; the next character
  379.     MULU    D7,D4
  380.     ADD.L    A3,D4
  381.     MOVE.L    D4,A0
  382.  
  383.     CLEAR    D5        ; Get font data of next in pair (if there's
  384.     MOVE.B    (A4)+,D5    ; not really a second character (odd-numbered
  385.     MULU    D7,D5        ; string lengths) then this second move
  386.     ADD.L    A3,D5        ; will be unnecessary, but at least is
  387.     MOVE.L    D5,A1
  388.                 ; harmless since the buffer is *always*
  389.                 ; pair-sized and the speed improvement is
  390.                 ; great when handling two characters at once)
  391.  
  392.     MOVE.W    D1,D6        ; Build the bltsize word
  393.     MOVE.L    D3,A5
  394.  
  395. SLIM_SLOW_BUILD:
  396.     MOVE.B    (A0)+,(A5)+
  397.     MOVE.B    (A1)+,(A5)
  398.     ADD.L    D0,A5
  399.     DBRA    D6,SLIM_SLOW_BUILD
  400.  
  401.     ADDQ.L    #2,D3        ; Advance destination pointer to next word
  402.  
  403.     DBRA    D2,SLIM_SLOW_PAIRLOOP ; Count down the pairs to print 
  404.  
  405.     MOVE.L (SP)+,A5        ; Restore A5 at end of SLIM_BUILD 
  406.  
  407. * Done, so fall into starting setting up the planes 
  408.  
  409.  
  410.  
  411. PLANESET:
  412. * Well, that was quick, wasn't it.  Here all of the required planes (except
  413. * the bothersome Inverted Text Plane) are ready to go.    So let's figure
  414. * out how to initialize the plane pointers in the BitMap ...
  415.  
  416.     LEA    xt_TextBitMap(A2),A3
  417.     LEA    bm_Planes(A3),A4    ; Get address of first plane pointer
  418.  
  419.     CLEAR    D0            ; Set up the pen-test mask
  420.     MOVE.W    FRONTPEN(SP),D1        ; Fetch the foreground pen
  421.     MOVE.W    BACKPEN(SP),D2        ; and the background pen
  422.     CLEAR    D3
  423.     MOVE.B    bm_Depth(A3),D3        ; Get the BitMap depth ...
  424.     SUBQ.W    #1,D3            ; ... and set the loop count for DBRA
  425.     CLEAR    D4            ; Clear the Inverted flag
  426.  
  427.  
  428. PLANELOOP:
  429. * First, find out if the foreground/background pattern for this plane 
  430. * is 00, 01, 10 or 11.  based on the pattern, select the associated 
  431. * plane pointer for the BitMap
  432.     BTST    D0,D1        ; If the bit is set in the foreground pen
  433.     BNE    PAT_ONE        ; then go process 1x combinations
  434.  
  435. * Else we have a 0x combination.  Which one is it?
  436.     BTST    D0,D2        ; This time test the background pen
  437.     BNE    PAT_01        ; and if set then our pattern is 01
  438.  
  439. PAT_00:
  440.     MOVE.L    xt_AllClearPlane(A2),A3 ; This plane is the 00 plane
  441.     BRA    PLANE_STUFF
  442.  
  443. PAT_01:
  444. * The dreaded Inverse Text Plane selector.  If it doesn't exist yet,
  445. * I have to create it now.
  446.     MOVE.L    xt_InverseTextPlane(A2),A3 ; This plane is the inverse plane
  447.     TST.B    D4        ; Test our Inverted Plane flag
  448.     BNE    PLANE_STUFF    ; and skip this mess if it's already set
  449.                 ; else we'll have to invert it.
  450.     ADDQ.B    #1,D4        ; Set the inversion flag
  451.  
  452. * OK, so use the blitter inversion algorithm:  Dest = NOT SRC.
  453.  
  454.     CLEAR    D5
  455.     MOVE.B    xt_MaxTextWidth(A2),D5 ; Build the Group-of-2 values:
  456.     MOVE.W    ARG2+2(SP),D6
  457.     ADDQ.W    #1,D6        ; Get the first multiple of 2 that's greater
  458.     ANDI.W    #$FFFE,D6    ; than or equal to the character count, and
  459.     SUB.W    D6,D5        ; subtract that from the total buffer width
  460.                 ; to make the Group-of-2 row modulo
  461.  
  462.     LSR.W    #1,D6        ; Turn char count into pair count
  463.     OR.W    XBLTSIZE(SP),D6    ; and prepare for starting the blitter
  464.  
  465.     MOVEM.L    D0-D1,-(SP)
  466.     CALLSYS    WaitBlit    ; Wait for the blitter before I jam it.
  467.     MOVEM.L    (SP)+,D0-D1
  468.  
  469.     MOVE.L    xt_NormalTextPlane(A2),bltbpt(A5)
  470.     MOVE.L    A3,bltdpt(A5)
  471.  
  472.     MOVE.W    D5,bltbmod(A5)    ; Set up the SRCB and DEST modulos
  473.     MOVE.W    D5,bltdmod(A5)
  474.  
  475.     MOVE.W    #$0533,bltcon0(A5)
  476.     MOVE.W    #$0000,bltcon1(A5)
  477.  
  478.     MOVE.W    D6,bltsize(A5)    ; Bombs away!
  479.             
  480.     BRA    PLANE_STUFF
  481.  
  482.  
  483. PAT_ONE:
  484. * We've got a 1x pattern.  Which one do you suppose it is?  Hmm ...
  485.     BTST    D0,D2        ; This time, test the back pen only
  486.     BNE    PAT_11
  487.  
  488.  
  489. PAT_10:
  490. * Normal Text Plane?  No problem.
  491.     MOVE.L    xt_NormalTextPlane(A2),A3
  492.     BRA    PLANE_STUFF
  493.  
  494. PAT_11:
  495.     MOVE.L    xt_AllSetPlane(A2),A3    ; This plane must have all bits set
  496.  
  497. * and fall into ...
  498.  
  499.  
  500. PLANE_STUFF:
  501. * OK, so A3 has the address of this plane's data.  Stuff that baby
  502. * into the BitMap structure.
  503.     MOVE.L    A3,(A4)+
  504.  
  505.     ADDQ    #1,D0        ; Advance our mask to the next position
  506.  
  507.     DBRA    D3,PLANELOOP    ; Loop on the depth of the BitMap
  508.  
  509.  
  510. * Now, all done with the private use of the blitter.  Here, I would prefer
  511. * to retain exclusive use of the blitter even throughout the call to
  512. * BlitBMRP below, but the system won't let me.  Too bad!
  513.  
  514.  
  515.     CALLSYS    DisownBlitter
  516.  
  517.  
  518. * Well, now the BitMap is all ready to blast out our new line
  519. * of text.  Wasn't that fun?  Now the simple final stroke:  zap that
  520. * data into the RastPort, using the ever-popular, cleverly-named
  521. * BltBitMapRastPort function (if Dale wasn't so good, I'd suggest
  522. * that we take him out and shoot him for that name).
  523. *
  524. * BlitBMRP wants:
  525. *
  526. * A0 = Source BitMap  
  527. * A1 = Destination RastPort
  528. * A6 = GfxBase
  529. *
  530. * D0 = Source X
  531. * D1 = Source Y
  532. * D2 = Destination X
  533. * D3 = Destination Y
  534. * D4 = Pixel Width of block to be moved
  535. * D5 = Scan-line Height of block to be moved
  536. * D6 = Minterm
  537.  
  538.     CLEAR    D5
  539.     MOVE.W    xt_CharHeight(A2),D5    ; Height of transfer
  540.  
  541.     MOVE.W    #XTEXT_CHARWIDTH,D4    ; Create the blit width ...
  542.     MOVE.W    ARG2+2(SP),D3        ; Character count
  543.     MULU    D3,D4            ; Width of transfer (creates LONG)
  544.  
  545.     MOVE.L    ARG4(SP),D3        ; Get the Y position into D3
  546.     MOVE.L    ARG3(SP),D2        ; Get the X position into D2
  547.  
  548.     CLEAR    D1            ; Source x and y are 0
  549.     CLEAR    D0
  550.  
  551.     MOVE.L    xt_OutputRPort(A2),A1    ; and get the RPort of the display
  552.  
  553.     LEA    xt_TextBitMap(A2),A0    ; Get the address of the BitMap arg
  554.  
  555. * The DrawMode defines what minterm we use and which routine we call.
  556.     CMP.W    #RP_JAM1,DRAWMODE(SP)    ; Are we doing JAM1?
  557.     BEQ    DO_JAM1
  558.  
  559. * The DrawMode can be JAM2 or COMPLEMENT.  Which is it, hmm?
  560.     MOVE.L    #$C0,D6            ; Minterm (simple transfer) for JAM2
  561.     CMP.W    #RP_JAM2,DRAWMODE(SP)    ; Is it really JAM2?
  562.     BEQ    BBMRP            ; Branch if so
  563.  
  564.     MOVE.L    #$60,D6            ; Only other is complement mode
  565.  
  566. BBMRP:
  567.     CALLSYS    BltBitMapRastPort    ; Do the normal (fast) BBMRP
  568.     BRA    RETURN
  569.  
  570.  
  571. DO_JAM1:
  572. * Call BltMaskBitMapRastPort, which is the same as BBMRP except that a
  573. * mask is used to cookie-cut the source into the destination.
  574. * JAM1 requires a mask, because JAM1 is cookie-cut!
  575. * The mask goes into A2.  If either pen was non-zero then we built 
  576. * the normal plane so use that as the mask,
  577. * else use the AllZeroPlane for the mask (which produces zip imagery!).
  578. * The minterm sez:  cut me in, daddio.
  579.  
  580.     MOVE.B    xt_DrawMode(A2),D6    ; Was this inverse video?
  581.     ANDI.B    #RP_INVERSVID,D6
  582.     BNE    1$            ; If so, use inverse JAM1 minterm
  583.     MOVE.L    #$E0,D6            ; else use normal JAM1 minterm
  584.     BRA    2$
  585.  
  586. 1$    MOVE.L    #$B0,D6
  587.  
  588. 2$    TST.W    FRONTPEN(SP)        ; Was the front pen zero?
  589.     BNE    3$            ; If not then get Normal for mask
  590.     TST.W    BACKPEN(SP)        ; Was the back pen zero?
  591.     BNE    3$            ; If not then get Normal for mask
  592.     MOVE.L    xt_AllClearPlane(A2),A2    ; AllClearPlane is the mask
  593.     BRA    4$
  594.  
  595. 3$    MOVE.L    xt_NormalTextPlane(A2),A2 ; use the plane as the mask
  596.  
  597. 4$    CALLSYS    BltMaskBitMapRastPort    ; Do the not-as-fast BMBMRP
  598.  
  599.  
  600.  
  601. RETURN:
  602.     MOVEM.L    (SP)+,A2-A6/D2-D7
  603.     LEA    8(SP),SP        ; Release memory of local variables
  604.  
  605.     RTS
  606.  
  607.  
  608.     END
  609.  
  610.  
  611.